﻿using System.IO;

namespace sync.Client
{
    class sWatcher
    {
      //Monitor Metadata change with given path

        private void watcherFoler(string folder)
        {
        //    // Create a new FileSystemWatcher and set its properties.
        //    watcher = new FileSystemWatcher();
        //    watcher.Path = folder;
        //    /* Watch for changes in LastAccess and LastWrite times, and
        //       the renaming of files or directories. */
        //    watcher.NotifyFilter =
        //        NotifyFilters.Attributes
        //        | NotifyFilters.CreationTime |
        //         NotifyFilters.LastAccess
        //        | NotifyFilters.Size | NotifyFilters.Security
        //        |
        //    NotifyFilters.LastWrite |
        //    NotifyFilters.FileName | NotifyFilters.DirectoryName;
        //    // Filter files.
        //    watcher.Filter = "*";
        //    watcher.IncludeSubdirectories = true;
        //    // Add event handlers.
        //    watcher.Changed += new FileSystemEventHandler(OnChanged);
        //    watcher.Created += new FileSystemEventHandler(OnCreate);
        //    watcher.Deleted += new FileSystemEventHandler(OnDelete);
        //    watcher.Renamed += new RenamedEventHandler(OnRenamed);
        //    // Begin watching.
        //    watcher.EnableRaisingEvents = true;
        }
        private void disableWatcher()
        {
        //    watcher.EnableRaisingEvents = false;
        //    watcher.Changed -= new FileSystemEventHandler(OnChanged);
        //    watcher.Created -= new FileSystemEventHandler(OnCreate);
        //    watcher.Deleted -= new FileSystemEventHandler(OnDelete);
        //    watcher.Renamed -= new RenamedEventHandler(OnRenamed);
        //    watcher.Dispose();
        }
        private void enableWatcher()
        {
        //    watcher.Changed += new FileSystemEventHandler(OnChanged);
        //    watcher.Created += new FileSystemEventHandler(OnCreate);
        //    watcher.Deleted += new FileSystemEventHandler(OnDelete);
        //    watcher.Renamed += new RenamedEventHandler(OnRenamed);
        //    watcher.EnableRaisingEvents = true;
        }
        private void OnChanged(object source, FileSystemEventArgs e)
        {
        //    try
        //    {
        //        string eName = e.Name.Substring(e.Name.LastIndexOf("\\") + 1);
        //        if (!new sFileMethods().filterFile(eName))
        //            return;
        //        string changeEvent = "|CL|" + client + "|DT|" + DateTime.Now + "|CT|" + e.ChangeType + "|FP|" + e.FullPath + "|FN|" + eName;
        //        listChange.Add(changeEvent);
        //    }
        //    catch (Exception ex)
        //    {
        //        notifyIcon1.ShowBalloonTip(2, "Sync", "OnChanged error \n" + ex.Message, ToolTipIcon.Info);
        //    }
        }
        private void OnCreate(object source, FileSystemEventArgs e)
        {
        //    try
        //    {
        //        string eName = e.Name.Substring(e.Name.LastIndexOf("\\") + 1);
        //        if (!new sFileMethods().filterFile(eName))
        //            return;
        //        string createEvent = "|CL|" + client + "|DT|" + DateTime.Now + "|CT|" + e.ChangeType + "|FP|" + e.FullPath + "|FN|" + eName;
        //        listChange.Add(createEvent);

        //    }
        //    catch (Exception ex)
        //    {
        //        notifyIcon1.ShowBalloonTip(2, "Sync", "OnCreated error \n" + ex.Message, ToolTipIcon.Info);
        //    }
        }
        private void OnDelete(object source, FileSystemEventArgs e)
        {
        //    try
        //    {

        //        string eName = e.Name.Substring(e.Name.LastIndexOf("\\") + 1);
        //        if (!new sFileMethods().filterFile(eName))
        //            return;
        //        string deleteEvent = "|CL|" + client + "|DT|" + DateTime.Now + "|CT|" + e.ChangeType + "|FP|" + e.FullPath + "|FN|" + eName;
        //        listChange.Add(deleteEvent);
        //    }
        //    catch (Exception ex)
        //    {
        //        notifyIcon1.ShowBalloonTip(2, "Sync", "OnDeleted error \n" + ex.Message, ToolTipIcon.Info);
        //    }
        }
        private void OnRenamed(object source, RenamedEventArgs e)
        {
        //    try
        //    {
        //        string eOldName = e.OldName.Substring(e.OldName.LastIndexOf("\\") + 1);
        //        string eName = e.Name.Substring(e.Name.LastIndexOf("\\") + 1);
        //        if (!new sFileMethods().filterFile(eName))
        //            return;
        //        string renameEvent = "|CL|" + client + "|DT|" + DateTime.Now + "|CT|" + e.ChangeType + "|OFP|" + e.OldFullPath + "|OFN|" + eOldName + "|NFP|" + e.FullPath + "|NFN|" + eName;
        //        listChange.Add(renameEvent);
        //    }
        //    catch (Exception ex)
        //    {
        //        notifyIcon1.ShowBalloonTip(2, "Sync", "OnRenamed error \n" + ex.Message, ToolTipIcon.Info);
        //    }
        }
        private void createChangeEvent(int idx, string[] arrayLog, string changeType)
        {
        //    string fullPath = arrayLog[idx].Substring(arrayLog[idx].LastIndexOf("|FP|") + 4, arrayLog[idx].LastIndexOf("|FN|") - arrayLog[idx].LastIndexOf("|FP|") - 4);
        //    string fileName = arrayLog[idx].Substring(arrayLog[idx].LastIndexOf("|FN|") + 4, arrayLog[idx].Length - arrayLog[idx].LastIndexOf("|FN|") - 4);
        //    string rootSV = new sClientInfo().pathClient.Replace("\\", "/");
        //    string fullPathSV = fullPath.Substring(rootSV.Length, fullPath.Length - rootSV.Length).Replace("\\", "/");
        //    string pathSV = fullPathSV.Substring(0, fullPathSV.Length - fileName.Length);
        //    string strDT = arrayLog[idx].Substring(arrayLog[idx].LastIndexOf("|DT|") + 4, arrayLog[idx].LastIndexOf("|CT|") - arrayLog[idx].LastIndexOf("|DT|") - 4);
        //    DateTime dtModify = DateTime.Now;
        //    try
        //    {
        //        dtModify = DateTime.Parse(strDT);
        //    }
        //    catch (Exception ex)
        //    {
        //        sms.error = ("CreateChangEvent: \n Datetime parse error :" + "\n" + ex.Message);
        //    }
        //    string changeTypeI = "", fullPathI = "";
        //    List<string> listA = new List<string>();
        //    for (int i = 0; i < arrayLog.Length; i++)
        //    {
        //        if (!arrayLog[i].Contains("|OFP|") && arrayLog[i].Trim() != "")
        //        {
        //            changeTypeI = arrayLog[i].Substring(arrayLog[i].LastIndexOf("|CT|") + 4, arrayLog[i].LastIndexOf("|FP|") - arrayLog[i].LastIndexOf("|CT|") - 4);
        //            fullPathI = arrayLog[i].Substring(arrayLog[i].LastIndexOf("|FP|") + 4, arrayLog[i].LastIndexOf("|FN|") - arrayLog[i].LastIndexOf("|FP|") - 4);
        //            if (fullPath == fullPathI && (changeTypeI == "Changed" || changeTypeI == "Created"))
        //            {
        //                listA.Add(arrayLog[i]);// if same full path and changetype=change or create,adding to listA
        //            }
        //        }

        //    }
        //    #region "Create file"
        //    if (File.Exists(fullPath))
        //    {
        //        //Async --- Upload file to Dropbox
        //        syncDataToSV = false;
        //        bool fileExist = false;
        //        _client.SearchAsync(fileName, pathSV,
        //            (response) =>
        //            {
        //                MetaData[] fileSearch = response.ToArray();
        //                for (int i = 0; i < fileSearch.Count(); i++)
        //                {
        //                    if (!fileSearch[i].Is_Dir)
        //                    {
        //                        if (fileSearch[i].Path.ToLower() == fullPathSV.ToLower())
        //                            fileExist = true;
        //                    }
        //                }
        //                if (!fileExist || fileSearch[0].ModifiedDate < dtModify)
        //                {
        //                    // Upload file to Server with async method
        //                    _client.UploadFileAsync(pathSV, fileName, File.ReadAllBytes(fullPath),
        //                    (responseUpload) =>
        //                    {
        //                        //Show message when upload success
        //                        sms.success = "\"" + fileName + "\"" + "was added";
        //                        //---Remove line when file upload success from file listlog
        //                        for (int i = 0; i < listA.Count; i++)
        //                        {
        //                            arrayLog = arrayLog.Where(w => w != listA[i]).ToArray();
        //                        }
        //                        //----------------------------
        //                        syncDataToSV = true;
        //                        new sRegistryMethods().Registry_Set("Cursor", _client.GetDelta(cursor).Cursor);
        //                    },
        //                    (error) =>
        //                    {
        //                        //show error message if file upload fail
        //                        sms.error = "Create File : upload " + fileName + " fail  \n" + error.Message;
        //                        syncDataToSV = true;
        //                    });
        //                }
        //                else
        //                {
        //                    for (int i = 0; i < listA.Count; i++)
        //                    {
        //                        arrayLog = arrayLog.Where(w => w != listA[i]).ToArray();
        //                    }
        //                    //----------------------------

        //                    syncDataToSV = true;
        //                }
        //            },
        //                (error) =>
        //                {
        //                    sms.error = error.Message;
        //                    syncDataToSV = true;
        //                });
        //    }
        //    #endregion
        //    #region "Create folder"
        //    else
        //        if (Directory.Exists(fullPath) && changeType == "Created")
        //        {
        //            // Async--- Create folder on dropbox
        //            bool folderExist = false;
        //            syncDataToSV = false;
        //            _client.SearchAsync(fileName, pathSV,
        //           (responseSearch) =>
        //           {
        //               MetaData[] folderSearch = responseSearch.ToArray();
        //               for (int i = 0; i < folderSearch.Count(); i++)
        //               {
        //                   if (folderSearch[i].Is_Dir)
        //                   {
        //                       if (folderSearch[i].Path == fullPathSV)
        //                           folderExist = true;
        //                   }
        //               }
        //               if (!folderExist)
        //               {
        //                   //Async --- Upload file to Dropbox
        //                   _client.CreateFolderAsync(fullPathSV,
        //                   (responseUpload) =>
        //                   {
        //                       try
        //                       {
        //                           //Show message when upload success
        //                           notifyIcon1.ShowBalloonTip(2, "Sync", "\"" + fileName + "\"" + " was created", ToolTipIcon.Info);
        //                           //---Remove line from file log
        //                           //----------------------------
        //                           for (int i = 0; i < listA.Count; i++)
        //                           {
        //                               arrayLog = arrayLog.Where(w => w != listA[i]).ToArray();
        //                           }
        //                           new sRegistryMethods().Registry_Set("Cursor", _client.GetDelta(cursor).Cursor);
        //                       }
        //                       catch (Exception ex)
        //                       {
        //                           showNotify(lineNB() + "\n" + ex.Message);
        //                       }
        //                       syncDataToSV = true;
        //                   },
        //                   (error) =>
        //                   {
        //                       //Do something on error
        //                       notifyIcon1.ShowBalloonTip(2, "Sync", "Create folder| upload " + fileName + " fail  \n" + error.Message, ToolTipIcon.Info);
        //                       syncDataToSV = true;
        //                   });
        //               }
        //               else
        //               {
        //                   try
        //                   {
        //                       arrayLog = arrayLog.Where(w => w != arrayLog[idx]).ToArray();
        //                   }
        //                   catch (Exception ex)
        //                   {
        //                       showNotify(lineNB() + "\n" + ex.Message);
        //                   }
        //                   syncDataToSV = true;
        //               }

        //           },
        //           (error) =>
        //           {

        //               notifyIcon1.ShowBalloonTip(2, "Sync", "Create folder | Search folder fail :\n" + error.Message, ToolTipIcon.Info);
        //               syncDataToSV = true;
        //           });

        //        }

        //        else
        //        {
        //            try
        //            {
        //                for (int i = 0; i < listA.Count; i++)
        //                {
        //                    arrayLog = arrayLog.Where(w => w != listA[i]).ToArray();
        //                }
        //            }
        //            catch (Exception ex)
        //            {
        //                showNotify(lineNB() + "\n" + ex.Message);
        //            }

        //            syncDataToSV = true;
        //        }
        //    #endregion
        }
        private void deleteEvent(int idx, string[] arrayLog)
        {
        //    string fullPath = arrayLog[idx].Substring(arrayLog[idx].LastIndexOf("|FP|") + 4, arrayLog[idx].LastIndexOf("|FN|") - arrayLog[idx].LastIndexOf("|FP|") - 4);
        //    string fileName = arrayLog[idx].Substring(arrayLog[idx].LastIndexOf("|FN|") + 4, arrayLog[idx].Length - arrayLog[idx].LastIndexOf("|FN|") - 4);
        //    string rootSV = new sClientInfo().pathClient.Replace("\\", "/");
        //    string fullPathSV = fullPath.Substring(rootSV.Length, fullPath.Length - rootSV.Length).Replace("\\", "/");
        //    string pathSV = fullPathSV.Substring(0, fullPathSV.Length - fileName.Length);
        //    string changeTypeI = "",
        //        fullPathI = "",
        //        getDir = Path.GetDirectoryName(fullPath),
        //        getDirI = "";
        //    List<string> listDirDel = new List<string>();
        //    if (!Directory.Exists(getDir))
        //        for (int i = 0; i < arrayLog.Length; i++)
        //        {
        //            if (!arrayLog[i].Contains("|OFP|") && arrayLog[i].Trim() != "")
        //            {
        //                changeTypeI = arrayLog[i].Substring(arrayLog[i].LastIndexOf("|CT|") + 4, arrayLog[i].LastIndexOf("|FP|") - arrayLog[i].LastIndexOf("|CT|") - 4);
        //                fullPathI = arrayLog[i].Substring(arrayLog[i].LastIndexOf("|FP|") + 4, arrayLog[i].LastIndexOf("|FN|") - arrayLog[i].LastIndexOf("|FP|") - 4);
        //                getDirI = Path.GetDirectoryName(fullPathI);
        //                if (getDir == getDirI || fullPathI.Contains(getDir))
        //                {
        //                    listDirDel.Add(arrayLog[i]);// if same full path and changetype=change or create,adding to listA
        //                }
        //            }

        //        }
        //    {
        //        // Async---Delete file on Dropbox
        //        bool fileSearchExist = false;
        //        syncDataToSV = false;
        //        //Check filename exist in Server

        //        _client.SearchAsync(fileName, pathSV,
        //        (responseSearch) =>
        //        {
        //            MetaData[] fileSearch = responseSearch.ToArray();
        //            for (int i = 0; i < fileSearch.Count(); i++)
        //            {
        //                if (!fileSearch[i].Is_Dir)
        //                {
        //                    if (fileSearch[i].Path.ToLower() == fullPathSV.ToLower())
        //                        fileSearchExist = true;
        //                }
        //                else
        //                    if (fileSearch[i].Is_Dir)
        //                    {
        //                        if (fileSearch[i].Path.ToLower() == fullPathSV.ToLower())
        //                            fileSearchExist = true;
        //                    }
        //            }
        //            if (fileSearchExist)
        //            {
        //                if (!Directory.Exists(getDir))
        //                    fullPathSV = pathSV;
        //                _client.DeleteAsync(fullPathSV, (response) =>
        //                {
        //                    //Do something
        //                    try
        //                    {
        //                        notifyIcon1.ShowBalloonTip(2, "Sync", "Deleted " + fileName, ToolTipIcon.Info);
        //                        //---Remove line from file log
        //                        if (!Directory.Exists(getDir))
        //                        {
        //                            for (int i = 0; i < listDirDel.Count; i++)
        //                            {
        //                                arrayLog = arrayLog.Where(w => w != listDirDel[i]).ToArray();
        //                            }
        //                        }
        //                        else
        //                            arrayLog = arrayLog.Where(w => w != arrayLog[idx]).ToArray();
        //                        new sRegistryMethods().Registry_Set("Cursor", _client.GetDelta(cursor).Cursor);
        //                        syncDataToSV = true;
        //                    }
        //                    catch (Exception ex)
        //                    {
        //                        showNotify(lineNB() + "\n" + ex.Message); syncDataToSV = true;
        //                    }

        //                },
        //                    (error) =>
        //                    {
        //                        //Do something on error
        //                        showNotify(lineNB() + "\n" + error.Message);
        //                        syncDataToSV = true;
        //                    });
        //            }
        //            else
        //            {
        //                try
        //                {
        //                    arrayLog = arrayLog.Where(w => w != arrayLog[idx]).ToArray();
        //                    syncDataToSV = true;
        //                }
        //                catch (Exception ex)
        //                {
        //                    showNotify(lineNB() + "\n" + ex.Message); syncDataToSV = true;
        //                }
        //                syncDataToSV = true;
        //            }
        //        },
        //            (error) =>
        //            {

        //                showNotify(lineNB() + "\n" + error.Message);
        //                syncDataToSV = true;
        //            });

        //    }
        }
        private void renameEvent(int idx, string[] arrayLog)
        {
        //    string oldfullPath = arrayLog[idx].Substring(arrayLog[idx].LastIndexOf("|OFP|") + 5, arrayLog[idx].LastIndexOf("|OFN|") - arrayLog[idx].LastIndexOf("|OFP|") - 5);
        //    string oldFileName = arrayLog[idx].Substring(arrayLog[idx].LastIndexOf("|OFN|") + 5, arrayLog[idx].LastIndexOf("|NFP|") - arrayLog[idx].LastIndexOf("|OFN|") - 5);


        //    string newFullPath = arrayLog[idx].Substring(arrayLog[idx].LastIndexOf("|NFP|") + 5, arrayLog[idx].LastIndexOf("|NFN|") - arrayLog[idx].LastIndexOf("|NFP|") - 5);
        //    string newFileName = arrayLog[idx].Substring(arrayLog[idx].LastIndexOf("|NFN|") + 5, arrayLog[idx].Length - arrayLog[idx].LastIndexOf("|NFN|") - 5);

        //    //Async --- Upload file to Dropbox
        //    string rootSV = new sClientInfo().pathClient.Replace("\\", "/");
        //    string oldFullPathSV = oldfullPath.Substring(rootSV.Length, oldfullPath.Length - rootSV.Length).Replace("\\", "/");
        //    string oldPathSV = oldFullPathSV.Substring(0, oldFullPathSV.Length - oldFileName.Length);
        //    string newFullPathSV = newFullPath.Substring(rootSV.Length, newFullPath.Length - rootSV.Length).Replace("\\", "/");
        //    string newPathSV = newFullPathSV.Substring(0, newFullPathSV.Length - newFileName.Length);
        //    // Async---Delete file on Dropbox
        //    #region "Rename file"
        //    if (File.Exists(newFullPath))
        //    {
        //        syncDataToSV = false;
        //        bool oldFileSVExist = false;

        //        _client.SearchAsync(oldFileName, oldPathSV,
        //            (responseSearchFile) =>
        //            {
        //                MetaData[] fileSearch = responseSearchFile.ToArray();
        //                for (int i = 0; i < fileSearch.Count(); i++)
        //                {
        //                    if (!fileSearch[i].Is_Dir)
        //                    {
        //                        if (fileSearch[i].Path.ToLower() == oldFullPathSV.ToLower())
        //                            oldFileSVExist = true;
        //                    }
        //                }
        //                if (oldFileSVExist)
        //                {
        //                    bool newFileSVExist = false;
        //                    _client.SearchAsync(newFileName, newPathSV,
        //                        (response1) =>
        //                        //Check filename exist in Server
        //                        {
        //                            MetaData[] file = response1.ToArray();
        //                            for (int i = 0; i < file.Count(); i++)
        //                            {
        //                                if (!file[i].Is_Dir)
        //                                {
        //                                    if (file[i].Path == newFullPathSV)
        //                                        newFileSVExist = true;
        //                                }
        //                            }
        //                            if (newFileSVExist)
        //                            {
        //                                _client.DeleteAsync(newFullPathSV, (response) =>
        //                                {
        //                                    //Do something
        //                                    new sRegistryMethods().Registry_Set("Cursor", _client.GetDelta(cursor).Cursor);
        //                                },
        //                                  (error) =>
        //                                  {
        //                                      //Do something on error
        //                                      notifyIcon1.ShowBalloonTip(2, "Sync", "Rename | Delete new file : " + newFileName + " fail :\n" + error.Message, ToolTipIcon.Info);
        //                                      syncDataToSV = true;
        //                                  });
        //                            }
        //                            _client.MoveAsync(oldFullPathSV, newFullPathSV,
        //                             (response) =>
        //                             {
        //                                 //Do something with response
        //                                 try
        //                                 {
        //                                     notifyIcon1.ShowBalloonTip(2, "Sync", newFileName + "was renamed success", ToolTipIcon.Info);

        //                                     //---Remove line from file log
        //                                     arrayLog = arrayLog.Where(w => w != arrayLog[idx]).ToArray();
        //                                     //----------------------------
        //                                     new sRegistryMethods().Registry_Set("Cursor", _client.GetDelta(cursor).Cursor);
        //                                 }
        //                                 catch (Exception ex)
        //                                 {
        //                                     showNotify(lineNB() + "\n" + ex.Message);
        //                                 }
        //                                 syncDataToSV = true;
        //                             },
        //                             (error) =>
        //                             {
        //                                 //Do something on error
        //                                 showNotify(lineNB() + "\n" + error.Message);
        //                                 syncDataToSV = true;
        //                             });
        //                        },
        //                         (error) =>
        //                         {
        //                             //Do something on error
        //                             showNotify(lineNB() + "\n" + error.Message);
        //                             syncDataToSV = true;
        //                         });
        //                }
        //                else
        //                {

        //                    bool fileExist = false;
        //                    _client.SearchAsync(newFileName, newPathSV,
        //                        (responseSearchNF) =>
        //                        {
        //                            MetaData[] file = responseSearchNF.ToArray();
        //                            //Check filename exist in Server
        //                            for (int i = 0; i < file.Count(); i++)
        //                            {
        //                                if (!file[i].Is_Dir)
        //                                {
        //                                    if (file[i].Path == newFullPath)
        //                                        fileExist = true;
        //                                }
        //                            }
        //                            if (fileExist)
        //                            {
        //                                _client.DeleteAsync(newFullPathSV, (response) =>
        //                                {
        //                                    //Do something
        //                                    new sRegistryMethods().Registry_Set("Cursor", _client.GetDelta(cursor).Cursor);
        //                                },
        //                                 (error) =>
        //                                 {
        //                                     //Do something on error
        //                                     showNotify(lineNB() + "\n" + error.Message);
        //                                 });
        //                            }

        //                            _client.UploadFileAsync(newPathSV, newFileName, File.ReadAllBytes(newFullPath),
        //                            (responseUpload) =>
        //                            {
        //                                //Show message when upload success
        //                                try
        //                                {
        //                                    notifyIcon1.ShowBalloonTip(2, "Sync", " Renamed " + oldFileName + " => " + newFileName, ToolTipIcon.Info);
        //                                    //---Remove line from file log
        //                                    arrayLog = arrayLog.Where(w => w != arrayLog[idx]).ToArray();
        //                                    //----------------------------
        //                                    new sRegistryMethods().Registry_Set("Cursor", _client.GetDelta(cursor).Cursor);
        //                                }
        //                                catch (Exception ex)
        //                                {
        //                                    showNotify(lineNB() + "\n" + ex.Message);
        //                                }
        //                                syncDataToSV = true;
        //                            },
        //                            (error) =>
        //                            {
        //                                //Do something on error
        //                                showNotify(lineNB() + "\n" + error.Message);
        //                                syncDataToSV = true;
        //                            });

        //                        },
        //                     (error) =>
        //                     {
        //                         showNotify(lineNB() + "\n" + error.Message);
        //                         syncDataToSV = true;
        //                     });

        //                }
        //            },
        //                (error) =>
        //                {
        //                    showNotify(lineNB() + "\n" + error.Message);
        //                    syncDataToSV = true;
        //                });
        //}

        //    #endregion
        //    #region "Rename folder"
        //    if (Directory.Exists(newFullPath))
        //    {
        //        // Check folder Exist in server
        //        bool folderExist = false;
        //        syncDataToSV = false;
        //        _client.SearchAsync(newFileName, newPathSV,
        //            (response1) =>
        //            {
        //                MetaData[] folderSearch = response1.ToArray();
        //                for (int i = 0; i < folderSearch.Count(); i++)
        //                {
        //                    if (folderSearch[i].Is_Dir)
        //                    {
        //                        if (folderSearch[i].Path == newFullPathSV)
        //                            folderExist = true;
        //                    }
        //                }

        //                if (folderExist == false)
        //                {
        //                    _client.MoveAsync(oldFullPathSV, newFullPathSV,
        //                         (response) =>
        //                         {
        //                             //Do something with response
        //                             try
        //                             {
        //                                 notifyIcon1.ShowBalloonTip(2, "Sync", newFileName + " was renamed success", ToolTipIcon.Info);
        //                                 //remove line
        //                                 arrayLog = arrayLog.Where(w => w != arrayLog[idx]).ToArray();
        //                                 new sRegistryMethods().Registry_Set("Cursor", _client.GetDelta(cursor).Cursor);
        //                             }
        //                             catch (Exception ex)
        //                             {
        //                                 showNotify(lineNB() + "\n" + ex.Message);
        //                             }
        //                             syncDataToSV = true;
        //                         },
        //                         (error) =>
        //                         {
        //                             //Do something on error
        //                             syncDataToSV = true;
        //                             showNotify(lineNB() + "\n" + error.Message);
        //                         });
        //                }
        //            },
        //        (error) =>
        //        {
        //            showNotify(lineNB() + "\n" + error.Message);
        //            syncDataToSV = true;
        //        });

        //    }
        //    else
        //    {
        //        arrayLog = arrayLog.Where(w => w != arrayLog[idx]).ToArray();
        //        syncDataToSV = true;
        //    }
        //    #endregion
        }
        private bool syncToServer()
        {
            //sFileMethods fl = new sFileMethods();
            //if (fl.IsFileLocked(logFile))
            //{
            //    syncDataToSV = true;
            //    return true;
            //}
            //string[] arrayLog;
            //{

            //    arrayLog = listChange.ToArray();
            //    if (arrayLog.Length == 0)
            //    {

            //        syncDataToSV = true;
            //        return true;
            //    }
            //    string line;
            //    int k = 0;
            //    line = arrayLog[k];
            //    if (line.Trim() != "")
            //    {

            //        int lineLength = line.Length;
            //        string changeType;
            //        if (line.Contains("|OFP|"))
            //            changeType = line.Substring(line.LastIndexOf("|CT|") + 4, line.LastIndexOf("|OFP|") - line.LastIndexOf("|CT|") - 4);
            //        else
            //        {
            //            changeType = line.Substring(line.LastIndexOf("|CT|") + 4, line.LastIndexOf("|FP|") - line.LastIndexOf("|CT|") - 4);
            //        }
            //        #region "Created event"
            //        if (changeType == "Created" || changeType == "Changed")
            //        {
            //            createChangeEvent(k, arrayLog, changeType);
            //        }
            //        #endregion

            //        #region "Deleted event"
            //        else
            //            if (changeType == "Deleted")
            //            {
            //                deleteEvent(k, arrayLog);
            //            }
            //        #endregion

            //            #region "Renamed event"
            //            else
            //                if (changeType == "Renamed")
            //                {
            //                    renameEvent(k, arrayLog);
            //                }
            //            #endregion
            //    }
            //    else
            //    {
            //        arrayLog = arrayLog.Where(w => w != line).ToArray();
            //        File.WriteAllLines(logFile, arrayLog);
            //        syncDataToSV = true;
            //    }
            //}
            //File.Delete(logFile);
            ////File.Move(fileTmp, logFile);
            //thrd.Start();
            return true;
        //syncDataToSV;
        }
        private void thrdCopyFolder(string path)
        {
            //pathCopyDir = path;
            //Thread thrd = new Thread(copyFolder);
            //thrd.Start();
        }
        string pathCopyDir;
        private void copyFolder()
        {
            //foreach (var folder in Directory.GetDirectories(pathCopyDir, "*", SearchOption.AllDirectories))
            //{
            //    string eName = folder.Substring(folder.LastIndexOf("\\") + 1);
            //    string line = "|CL|" + client + "|DT|" + DateTime.Now + "|CT|" + "Created" + "|FP|" + folder + "|FN|" + eName;
            //    listChange.Add(line);
            //}
            //foreach (var file in Directory.GetFiles(pathCopyDir, "*", SearchOption.AllDirectories))
            //{
            //    string eName = file.Substring(file.LastIndexOf("\\") + 1);
            //    string line = "|CL|" + client + "|DT|" + DateTime.Now + "|CT|" + "Created" + "|FP|" + file + "|FN|" + eName;
            //    listChange.Add(line);
            //}
        }
    }
}
